{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "2a793b1d-a0a9-404c-ada6-58937227cfce",
   "metadata": {},
   "source": [
    "# Puxa vida!\n",
    "\n",
    "Se você chegou até aqui, ainda está enfrentando problemas para configurar o seu ambiente. Sinto muito! Aguente firme e logo devemos colocar tudo para funcionar.\n",
    "\n",
    "Configurar um ambiente de Ciência de Dados pode ser desafiador porque há muita coisa acontecendo nos bastidores. Mas vamos chegar lá.\n",
    "\n",
    "E lembre-se: estou à disposição para ajudar. Envie uma mensagem ou e-mail para ed@edwarddonner.com e eu assumo o caso. A última célula deste notebook contém alguns diagnósticos que vão me ajudar a entender o que está acontecendo.\n",
    "\n",
    "Talvez você queira dar uma olhada rápida no [faq](https://edwarddonner.com/faq) do meu site caso o seu problema já esteja descrito por lá.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ebcd34f",
   "metadata": {},
   "source": [
    "# Se você está fazendo a nova versão do curso (usando uv e Cursor, em vez de Anaconda), confira esta seção primeiro; caso contrário, vá direto para a próxima seção intitulada \"Começando pelo básico\"\n",
    "\n",
    "## 1. Verifique as extensões do Cursor\n",
    "\n",
    "Só para confirmar que as extensões estão instaladas:\n",
    "- Abra as extensões (View >> Extensions)\n",
    "- Pesquise por python e, quando os resultados aparecerem, clique na ms-python e instale se ainda não estiver instalada\n",
    "- Pesquise por jupyter e, quando os resultados aparecerem, clique na da Microsoft e instale se ainda não estiver instalada  \n",
    "Depois vá em View >> Explorer para trazer de volta o File Explorer.\n",
    "\n",
    "## 2. Conecte este kernel:\n",
    "\n",
    "Se você vir as palavras `Select Kernel` em um botão próximo ao canto superior direito desta janela, clique nele!\n",
    "\n",
    "Você deve ver um menu suspenso com o título \"Select kernel for..\" ou talvez precise escolher \"Python environment\" primeiro.\n",
    "\n",
    "Escolha a opção que começa com `.venv python 3.12` — ela deve ser a primeira opção. Talvez seja necessário clicar em \"Python Environments\" antes.\n",
    "\n",
    "Agora deve estar escrito `.venv (Python 3.12.x)` onde antes aparecia `Select Kernel`.\n",
    "\n",
    "Depois de clicar em \"Select Kernel\", se não houver nenhuma opção como `.venv (Python 3.12.x)`, siga o passo a passo:  \n",
    "1. No Mac: no menu Cursor, escolha Settings >> VS Code Settings (ATENÇÃO: selecione `VSCode Settings`, não `Cursor Settings`);  \n",
    "Ou no Windows PC: no menu File, escolha Preferences >> VS Code Settings (ATENÇÃO: selecione `VSCode Settings`, não `Cursor Settings`)  \n",
    "2. Na barra de busca das configurações, digite \"venv\"  \n",
    "3. No campo \"Path to folder with a list of Virtual Environments\", informe o caminho da raiz do projeto, como C:\\Users\\username\\projects\\llm_engineering (no Windows) ou /Users/username/projects/llm_engineering (no Mac ou Linux).  \n",
    "Em seguida, tente novamente.\n",
    "\n",
    "## 3. Problemas com o uv\n",
    "\n",
    "Confira este guia completo no meu [FAQ Q11](https://edwarddonner.com/faq/#11)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98787335-346f-4ee4-9cb7-6181b0e1b964",
   "metadata": {},
   "source": [
    "# Começando pelo básico\n",
    "\n",
    "## Verificando sua conexão com a internet\n",
    "\n",
    "Primeiro, vamos verificar se não há problemas com VPN, firewall ou certificados.\n",
    "\n",
    "Clique na célula abaixo e pressione Shift+Return para executá-la.  \n",
    "Se isso gerar problemas, tente seguir estas instruções para resolver:  \n",
    "https://chatgpt.com/share/676e6e3b-db44-8012-abaa-b3cf62c83eb3\n",
    "\n",
    "Também ouvi que você pode ter problemas se estiver usando um computador corporativo com o software de segurança zscaler.\n",
    "\n",
    "Alguns conselhos de alunos nessa situação com o zscaler:\n",
    "\n",
    "> No prompt do Anaconda, isto ajudou às vezes, embora ainda ocorressem falhas ocasionais ao executar código no Jupyter:\n",
    "`conda config --set ssl_verify false`  \n",
    "Outra coisa que ajudou foi adicionar `verify=False` sempre que houver `request.get(..)`, então `request.get(url, headers=headers)` se torna `request.get(url, headers=headers, verify=False)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d296f9b6-8de4-44db-b5f5-9b653dfd3d81",
   "metadata": {},
   "outputs": [],
   "source": [
    "import urllib.request\n",
    "\n",
    "try:\n",
    "    response = urllib.request.urlopen(\"https://www.google.com\", timeout=10)\n",
    "    if response.status != 200:\n",
    "        print(\"Não foi possível acessar o Google - pode haver problemas com sua internet / VPN / firewall?\")\n",
    "    else:\n",
    "        print(\"Conectado à internet e com acesso ao Google\")\n",
    "except Exception as e:\n",
    "    print(f\"Falha na conexão com este erro: {e}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d91da3b2-5a41-4233-9ed6-c53a7661b328",
   "metadata": {},
   "source": [
    "## Mais alguns \"perrengues\" ocasionais para quem está no PC\n",
    "\n",
    "Existem 4 armadilhas no Windows das quais você deve estar ciente:  \n",
    "1. Permissões. Consulte este [tutorial](https://chatgpt.com/share/67b0ae58-d1a8-8012-82ca-74762b0408b0) sobre permissões no Windows\n",
    "2. Antivírus, firewall e VPN. Eles podem interferir em instalações e no acesso à rede; tente desativá-los temporariamente, se necessário\n",
    "3. O terrível limite de 260 caracteres para nomes de arquivo no Windows - aqui está uma [explicação e correção](https://chatgpt.com/share/67b0afb9-1b60-8012-a9f7-f968a5a910c7) completas!\n",
    "4. Se você nunca trabalhou com pacotes de Ciência de Dados no seu computador, talvez precise instalar o Microsoft Build Tools. Aqui estão as [instruções](https://chatgpt.com/share/67b0b762-327c-8012-b809-b4ec3b9e7be0). Um aluno também mencionou que [estas instruções](https://github.com/bycloudai/InstallVSBuildToolsWindows) podem ser úteis para quem está no Windows 11.  \n",
    "\n",
    "## E para quem usa Mac\n",
    "\n",
    "1. Se você está começando a desenvolver no Mac, pode precisar instalar as ferramentas de desenvolvedor do XCode. Aqui estão as [instruções](https://chatgpt.com/share/67b0b8d7-8eec-8012-9a37-6973b9db11f5).\n",
    "2. Assim como no PC, antivírus, firewall e VPN podem causar problemas. Eles interferem em instalações e no acesso à rede; tente desativá-los temporariamente, se necessário"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5190688-205a-46d1-a0dc-9136a42ad0db",
   "metadata": {},
   "source": [
    "# Passo 1\n",
    "\n",
    "Tente executar a próxima célula (clique na célula abaixo desta e pressione shift+return).\n",
    "\n",
    "Se isso gerar um erro, provavelmente você não está executando em um ambiente \"ativado\". Consulte a Parte 5 do guia SETUP para [PC](../SETUP-PC.md) ou [Mac](../SETUP-mac.md) para configurar o ambiente Anaconda (ou virtualenv) e ativá-lo antes de rodar `jupyter lab`.\n",
    "\n",
    "Se observar o prompt do Anaconda (PC) ou o Terminal (Mac), você deve ver `(llms)` no prompt onde inicia `jupyter lab` - esse é o sinal de que o ambiente llms está ativado.\n",
    "\n",
    "Se você já estiver em um ambiente ativado, a próxima tentativa é reiniciar tudo:\n",
    "1. Feche todas as janelas do Jupyter, como esta aqui\n",
    "2. Encerre todos os prompts de comando / terminais / Anaconda\n",
    "3. Repita a Parte 5 das instruções de SETUP para iniciar um novo ambiente ativado e executar `jupyter lab` a partir do diretório `llm_engineering`  \n",
    "4. Volte a este notebook e vá em Kernel >> Restart Kernel and Clear Outputs of All Cells\n",
    "5. Tente executar novamente a célula abaixo.\n",
    "\n",
    "Se **isso** não funcionar, entre em contato comigo! Vou responder rapidamente e vamos resolver. Execute os diagnósticos (última célula deste notebook) para que eu possa depurar. Se você usou Anaconda, pode ser que, por algum motivo, o ambiente tenha sido corrompido; nesse caso, a solução mais simples é usar a abordagem com virtualenv (Parte 2B nos guias de setup)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c8c0bb3-0e94-466e-8d1a-4dfbaa014cbe",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Algumas verificações rápidas para garantir que o seu ambiente Conda ou VirtualEnv está como esperado\n",
    "# O nome do ambiente deve ser: llms\n",
    "\n",
    "import os\n",
    "conda_name, venv_name = \"\", \"\"\n",
    "\n",
    "conda_prefix = os.environ.get('CONDA_PREFIX')\n",
    "if conda_prefix:\n",
    "    print(\"O ambiente Anaconda está ativo:\")\n",
    "    print(f\"Caminho do ambiente: {conda_prefix}\")\n",
    "    conda_name = os.path.basename(conda_prefix)\n",
    "    print(f\"Nome do ambiente: {conda_name}\")\n",
    "\n",
    "virtual_env = os.environ.get('VIRTUAL_ENV')\n",
    "if virtual_env:\n",
    "    print(\"O virtualenv está ativo:\")\n",
    "    print(f\"Caminho do ambiente: {virtual_env}\")\n",
    "    venv_name = os.path.basename(virtual_env)\n",
    "    print(f\"Nome do ambiente: {venv_name}\")\n",
    "\n",
    "if conda_name != \"llms\" and venv_name != \"llms\" and venv_name != \"venv\" and venv_name != \".venv\":\n",
    "    print(\"Nem o Anaconda nem o virtualenv parecem estar ativados com o nome esperado 'llms', 'venv' ou '.venv'\")\n",
    "    print(\"Você executou 'jupyter lab' a partir de um ambiente ativado com (llms) aparecendo na linha de comando?\")\n",
    "    print(\"Em caso de dúvida, feche todos os jupyter lab e siga a Parte 5 do guia SETUP-PC ou SETUP-mac.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45e2cc99-b7d3-48bd-b27c-910206c4171a",
   "metadata": {},
   "source": [
    "# Passo 1.1\n",
    "\n",
    "## Hora de verificar se o ambiente está configurado e as dependências foram instaladas\n",
    "\n",
    "Agora, a próxima célula deve executar sem gerar saída — sem erros de importação.  \n",
    "\n",
    "Para quem está na nova versão do curso (a partir de outubro de 2025), um erro indica que o kernel selecionado não é o correto.\n",
    "\n",
    "Para quem está na versão original do curso:\n",
    "\n",
    "> Erros de importação podem indicar que você iniciou o jupyter lab sem ativar o ambiente. Veja a Parte 5 do SETUP.  \n",
    "> Talvez seja preciso reiniciar o kernel e o Jupyter Lab.  \n",
    "> Ou pode haver algo errado com o Anaconda. Nesse caso, siga estas instruções de recuperação:  \n",
    "> Primeiro, feche tudo e reinicie o computador.  \n",
    "> Depois, em um Anaconda Prompt (PC) ou Terminal (Mac), com o ambiente ativado e **(llms)** aparecendo no prompt, no diretório llm_engineering, execute:  \n",
    "> `python -m pip install --upgrade pip`  \n",
    "> `pip install --retries 5 --timeout 15 --no-cache-dir --force-reinstall -r requirements.txt`  \n",
    "> Observe cuidadosamente se há erros e me avise.  \n",
    "> Se receber instruções para instalar o Microsoft Build Tools ou o Apple XCode, siga essas instruções.  \n",
    "> Depois, tente novamente!\n",
    "> Por fim, se ainda assim não der certo, experimente a Parte 2B do SETUP, a alternativa à Parte 2 (com Python 3.11 ou Python 3.12).  \n",
    "> Se continuar em dúvida, rode os diagnósticos (última célula deste notebook) e me envie um e-mail em ed@edwarddonner.com"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6c78b7d9-1eea-412d-8751-3de20c0f6e2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Este import deve funcionar se o seu ambiente estiver ativo e as dependências estiverem instaladas!\n",
    "\n",
    "from openai import OpenAI"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b66a8460-7b37-4b4c-a64b-24ae45cf07eb",
   "metadata": {},
   "source": [
    "# Passo 2\n",
    "\n",
    "Vamos verificar se o seu arquivo .env existe e se a chave da OpenAI está configurada corretamente nele.  \n",
    "Execute este código e verifique se ele exibe uma mensagem de sucesso; do contrário, siga as instruções dele.\n",
    "\n",
    "Se não houver sucesso, o código não conseguiu encontrar um arquivo chamado `.env` na pasta `llm_engineering`.  \n",
    "O nome do arquivo precisa ser exatamente `.env` - não vai funcionar se ele se chamar `my-keys.env` ou `.env.doc`.  \n",
    "É possível que o `.env` na verdade esteja com o nome `.env.txt`? No Windows, talvez seja necessário alterar uma configuração no File Explorer para garantir que as extensões de arquivo apareçam (\"Show file extensions\" em \"On\"). Você também deve ver as extensões se digitar `dir` no diretório `llm_engineering`.\n",
    "\n",
    "Alguns detalhes traiçoeiros para observar:  \n",
    "- No arquivo .env, não deve haver espaço entre o sinal de igual e a chave. Exemplo: `OPENAI_API_KEY=sk-proj-...`\n",
    "- Se você copiou e colou sua chave de outro aplicativo, certifique-se de que os hífens não foram substituídos por traços longos  \n",
    "\n",
    "Observe que o arquivo `.env` não aparece no navegador de arquivos do Jupyter Lab, porque o Jupyter oculta arquivos que começam com ponto por segurança; eles são considerados arquivos ocultos. Se precisar alterar o nome, use um terminal ou o File Explorer (PC) / Finder (Mac). Se isso estiver difícil, peça ajuda ao ChatGPT ou me envie um e-mail!\n",
    "\n",
    "Se estiver com dificuldade para criar o arquivo `.env`, podemos fazê-lo com código! Veja a célula após a próxima.\n",
    "\n",
    "É importante iniciar o `jupyter lab` a partir do diretório raiz do projeto, `llm_engineering`. Se não tiver feito isso, esta célula pode apresentar problemas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "caa4837e-b970-4f89-aa9a-8aa793c754fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "parent_dir = Path(\"..\")\n",
    "env_path = parent_dir / \".env\"\n",
    "\n",
    "if env_path.exists() and env_path.is_file():\n",
    "    print(\"Arquivo .env encontrado.\")\n",
    "\n",
    "    # Ler o conteúdo do arquivo .env\n",
    "    with env_path.open(\"r\") as env_file:\n",
    "        contents = env_file.readlines()\n",
    "\n",
    "    key_exists = any(line.startswith(\"OPENAI_API_KEY=\") for line in contents)\n",
    "    good_key = any(line.startswith(\"OPENAI_API_KEY=sk-proj-\") for line in contents)\n",
    "    classic_problem = any(\"OPEN_\" in line for line in contents)\n",
    "    \n",
    "    if key_exists and good_key:\n",
    "        print(\"SUCESSO! OPENAI_API_KEY encontrada e com o prefixo correto\")\n",
    "    elif key_exists:\n",
    "        print(\"Foi encontrada uma OPENAI_API_KEY, mas ela não tinha o prefixo esperado sk-proj- \\nPor favor, confira sua chave no arquivo..\")\n",
    "    elif classic_problem:\n",
    "        print(\"Não encontrei uma OPENAI_API_KEY, mas percebi que 'OPEN_' aparece - será que há um erro de digitação como OPEN_API_KEY em vez de OPENAI_API_KEY?\")\n",
    "    else:\n",
    "        print(\"Não encontrei uma OPENAI_API_KEY no arquivo .env\")\n",
    "else:\n",
    "    print(\"Arquivo .env não encontrado no diretório llm_engineering. Ele precisa ter exatamente o nome: .env\")\n",
    "    \n",
    "    possible_misnamed_files = list(parent_dir.glob(\"*.env*\"))\n",
    "    \n",
    "    if possible_misnamed_files:\n",
    "        print(\"\\nAviso: nenhum arquivo '.env' foi encontrado, mas os seguintes arquivos no diretório llm_engineering contêm '.env' no nome. Talvez seja preciso renomeá-los?\")\n",
    "        for file in possible_misnamed_files:\n",
    "            print(file.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "105f9e0a-9ff4-4344-87c8-e3e41bc50869",
   "metadata": {},
   "source": [
    "## Plano B - código em Python para criar o arquivo .env para você\n",
    "\n",
    "Execute a próxima célula apenas se estiver com problemas para criar o arquivo .env.  \n",
    "Substitua o texto na primeira linha de código pela sua chave da OpenAI."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ab9ea6ef-49ee-4899-a1c7-75a8bd9ac36b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Execute este código apenas se quiser que um arquivo .env seja criado para você!\n",
    "\n",
    "# Coloque sua chave entre as aspas\n",
    "make_me_a_file_with_this_key = \"coloque sua chave aqui entre estas aspas.. ela deve começar com sk-proj-\"\n",
    "\n",
    "# Altere para True se você já tiver um arquivo .env e quiser que eu o substitua\n",
    "overwrite_if_already_exists = False \n",
    "\n",
    "from pathlib import Path\n",
    "\n",
    "parent_dir = Path(\"..\")\n",
    "env_path = parent_dir / \".env\"\n",
    "\n",
    "if env_path.exists() and not overwrite_if_already_exists:\n",
    "    print(\"Já existe um arquivo .env - se quiser que eu crie um novo, defina a variável overwrite_if_already_exists como True acima\")\n",
    "else:\n",
    "    try:\n",
    "        with env_path.open(mode='w', encoding='utf-8') as env_file:\n",
    "            env_file.write(f\"OPENAI_API_KEY={make_me_a_file_with_this_key}\")\n",
    "        print(f\".env criado com sucesso em {env_path}\")\n",
    "        if not make_me_a_file_with_this_key.startswith(\"sk-proj-\"):\n",
    "            print(f\"A chave fornecida começou com '{make_me_a_file_with_this_key[:8]}', diferente de sk-proj-; era isso mesmo que você queria?\")\n",
    "        print(\"Agora execute novamente a célula anterior para confirmar que o arquivo foi criado e que a chave está correta.\")\n",
    "    except Exception as e:\n",
    "        print(f\"Ocorreu um erro ao criar o arquivo .env: {e}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ba9420d-3bf0-4e08-abac-f2fbf0e9c7f1",
   "metadata": {},
   "source": [
    "# Passo 3\n",
    "\n",
    "Agora vamos verificar se sua chave de API está configurada corretamente no arquivo `.env` e disponível com o pacote dotenv.\n",
    "Tente executar a próxima célula."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ee8e613-5a6e-4d1f-96ef-91132da545c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Esta célula deve exibir sua chave de API na saída - siga as instruções impressas\n",
    "\n",
    "import os\n",
    "from dotenv import load_dotenv\n",
    "load_dotenv(override=True)\n",
    "\n",
    "api_key = os.getenv(\"OPENAI_API_KEY\")\n",
    "\n",
    "if not api_key:\n",
    "    print(\"Nenhuma chave de API foi encontrada - tente Kernel >> Restart Kernel And Clear Outputs of All Cells\")\n",
    "elif not api_key.startswith(\"sk-proj-\"):\n",
    "    print(f\"Uma chave de API foi encontrada, mas ela começa com {api_key[:8]} em vez de sk-proj-; por favor, confirme se isso está correto.\")\n",
    "elif api_key.strip() != api_key:\n",
    "    print(\"Uma chave de API foi encontrada, mas parece haver espaços ou tabulações no início ou no fim - remova-os, por favor\")\n",
    "else:\n",
    "    print(\"Chave de API encontrada e tudo parece correto até agora!\")\n",
    "\n",
    "if api_key:\n",
    "    problematic_unicode_chars = ['\\u2013', '\\u2014', '\\u201c', '\\u201d', '\\u2026', '\\u2018', '\\u2019']\n",
    "    forbidden_chars = [\"'\", \" \", \"\\n\", \"\\r\", '\"']\n",
    "    \n",
    "    if not all(32 <= ord(char) <= 126 for char in api_key):\n",
        "        print(\"Possível problema: talvez haja caracteres não imprimíveis incluídos na chave?\")\n",
    "    elif any(char in api_key for char in problematic_unicode_chars):\n",
        "        print(\"Possível problema: talvez haja caracteres especiais, como traços longos ou aspas curvas na chave - você copiou de um editor de texto?\")\n",
    "    elif any(char in api_key for char in forbidden_chars):\n",
        "        print(\"Possível problema: há aspas, espaços ou linhas em branco na sua chave?\")\n",
    "    else:\n",
        "        print(\"A chave de API contém caracteres válidos\")\n",
    "    \n",
    "print(f\"\\nAqui está a chave --> {api_key} <--\")\n",
    "print()\n",
    "print(\"Se a chave estiver correta, vá em Edit >> Clear Cell Output para que ela não fique visível aqui!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f403e515-0e7d-4be4-bb79-5a102dbd6c94",
   "metadata": {},
   "source": [
    "## Deve aparecer algumas verificações com algo assim:\n",
    "\n",
    "`Here is the key --> sk-proj-blahblahblah <--`\n",
    "\n",
    "Se nenhuma chave foi exibida, espero que as mensagens tenham dado informação suficiente para resolver. Caso contrário, fale comigo!\n",
    "\n",
    "Existe ainda um último recurso, se preferir: você pode dispensar o uso de arquivos .env e sempre fornecer sua chave de API manualmente.  \n",
    "Sempre que encontrar isto no código:  \n",
    "`openai = OpenAI()`  \n",
    "Você pode substituir por:  \n",
    "`openai = OpenAI(api_key=\"sk-proj-xxx\")`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42afad1f-b0bf-4882-b469-7709060fee3a",
   "metadata": {},
   "source": [
    "# Passo 4\n",
    "\n",
    "Agora execute o código abaixo e, com sorte, você verá que o GPT consegue lidar com aritmética básica!!\n",
    "\n",
    "Se não funcionar, veja a célula abaixo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cccb58e7-6626-4033-9dc1-e7e3ff742f6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from openai import OpenAI\n",
    "from dotenv import load_dotenv\n",
    "load_dotenv(override=True)\n",
    "\n",
    "my_api_key = os.getenv(\"OPENAI_API_KEY\")\n",
    "\n",
    "print(f\"Usando a chave de API --> {my_api_key} <--\")\n",
    "\n",
    "openai = OpenAI()\n",
    "completion = openai.chat.completions.create(\n",
    "    model='gpt-4o-mini',\n",
    "    messages=[{\"role\":\"user\", \"content\": \"What's 2+2?\"}],\n",
    ")\n",
    "print(completion.choices[0].message.content)\n",
    "print(\"Agora vá em Edit >> Clear Cell Output para remover a exibição da sua chave.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81046a77-c359-4388-929f-ffc8ad5cb93c",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "source": [
    "## Se a chave foi configurada corretamente e ainda assim não funcionou\n",
    "\n",
    "### Se houver um erro da OpenAI sobre a sua chave ou um Rate Limit Error, há algo de errado com a sua chave de API!\n",
    "\n",
    "Primeiro, confira [esta página](https://platform.openai.com/settings/organization/billing/overview) para garantir que você tem saldo positivo.\n",
    "A OpenAI exige que você mantenha um saldo positivo e estabelece valores mínimos, normalmente em torno de US$5 na moeda local. Minha defesa da OpenAI é que isso vale muito para a sua formação: por menos do que o preço de um álbum de música, você ganha uma grande experiência comercial. Mas isso não é obrigatório para o curso; o README traz instruções para usar modelos open-source gratuitos via Ollama sempre que utilizarmos a OpenAI.\n",
    "\n",
    "A página de cobrança da OpenAI com o saldo fica aqui:  \n",
    "https://platform.openai.com/settings/organization/billing/overview  \n",
    "A OpenAI pode levar alguns minutos para liberar sua chave depois que você reforça o saldo.  \n",
    "Um aluno fora dos EUA comentou que precisou habilitar pagamentos internacionais no cartão de crédito para que tudo funcionasse.  \n",
    "\n",
    "É improvável, mas se houver algo de errado com sua chave, você pode tentar criar uma nova (botão no canto superior direito) aqui:  \n",
    "https://platform.openai.com/api-keys\n",
    "\n",
    "### Verifique se você consegue usar o gpt-4o-mini no playground da OpenAI\n",
    "\n",
    "Para confirmar que a cobrança está ativa e sua chave está válida, experimente usar o gtp-4o-mini diretamente:  \n",
    "https://platform.openai.com/playground/chat?models=gpt-4o-mini\n",
    "\n",
    "### Se houver um erro relacionado a certificados\n",
    "\n",
    "Se você encontrou um erro de certificados como:  \n",
    "`ConnectError: [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get local issuer certificate (_ssl.c:1000)`  \n",
    "Então substitua:\n",
    "`openai = OpenAI()`  \n",
    "por:  \n",
    "`import httpx`  \n",
    "`openai = OpenAI(http_client=httpx.Client(verify=False))`  \n",
    "E substitua também:  \n",
    "`requests.get(url, headers=headers)`  \n",
    "por:  \n",
    "`requests.get(url, headers=headers, verify=False)`  \n",
    "Se isso funcionar, você está em boa forma. Será preciso ajustar os labs do mesmo jeito sempre que encontrar esse erro de certificado.  \n",
    "Essa abordagem não é adequada para código de produção, mas serve para nossos experimentos. Talvez seja necessário falar com o suporte de TI para entender se há restrições no seu ambiente.\n",
    "\n",
    "## Se nada disso funcionar:\n",
    "\n",
    "(1) Tente colar o seu erro no ChatGPT ou no Claude! É impressionante como eles resolvem muitas situações\n",
    "\n",
    "(2) Tente criar outra chave, substituir no arquivo .env e executar novamente!\n",
    "\n",
    "(3) Fale comigo! Rode os diagnósticos na célula abaixo e me envie um e-mail com os problemas para ed@edwarddonner.com\n",
    "\n",
    "Muito obrigado, e desculpe por todo esse transtorno!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc83f944-6ce0-4b5c-817f-952676e284ec",
   "metadata": {},
   "source": [
    "# Coletando informações diagnósticas essenciais\n",
    "\n",
    "## Execute a próxima célula para coletar alguns dados importantes\n",
    "\n",
    "Execute a próxima célula; ela deve levar cerca de um minuto para rodar. A maior parte desse tempo verifica a sua largura de banda.\n",
    "Depois, envie por e-mail o resultado da última célula para ed@edwarddonner.com.  \n",
    "Como alternativa: isso criará um arquivo chamado report.txt - basta anexá-lo ao seu e-mail."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "248204f0-7bad-482a-b715-fb06a3553916",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Execute meu relatório de diagnósticos para coletar informações essenciais de depuração\n",
    "# Por favor, envie os resultados por e-mail. Você pode copiar e colar a saída ou anexar o arquivo report.txt\n",
    "\n",
    "!pip install -q requests speedtest-cli psutil setuptools\n",
    "from diagnostics import Diagnostics\n",
    "Diagnostics().run()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1955b9a-d344-4782-b448-2770d0edd90c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
